#include <iostream>
#include <pthread.h>
using namespace std;

class ThreadData
{
public:
    ThreadData(int a, int b):_a(a), _b(b)
    {}

    int _a;
    int _b;
};

void* Print(void* arg)
{
    ThreadData* ptd = static_cast<ThreadData*>(arg);
    cout << ptd->_a << " " << ptd->_b << endl;
}

int main()
{
    pthread_t tid;
    ThreadData td(10, 20);
    pthread_create(&tid, nullptr, Print, (void*)&td);

    pthread_join(tid, nullptr);
    return 0;
}

// #include <iostream>
// #include <ctime>
// #include <unistd.h>
// #include "BlockingQueue.hpp"
// #include "Task.hpp"

// using namespace std;

// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// void *producer(void *arg)
// {
//     blqueue<Task> *blq = static_cast<blqueue<Task> *>(arg);

//     // 生产数据
//     while (true)
//     {
//         Task task;
//         task.SetNum();
//         blq->Push(task);

//         pthread_mutex_lock(&mutex);
//         cout << "producer：" << task() << " : " << pthread_self() << endl;
//         pthread_mutex_unlock(&mutex);

//         // sleep(1);
//     }
//     return nullptr;
// }

// void *consumer(void *arg)
// {
//     sleep(2);
//     blqueue<Task> *blq = static_cast<blqueue<Task> *>(arg);

//     // 消费数据
//     while (true)
//     {
//         Task task;
//         blq->Pop(&task);

//         pthread_mutex_lock(&mutex);
//         cout << "consumer：" << task() << " : " <<pthread_self() << endl;
//         pthread_mutex_unlock(&mutex);

//         sleep(1);
//     }

//     return nullptr;
// }

// int main()
// {
//     srand((unsigned)time(nullptr));

//     blqueue<Task> *blq = new blqueue<Task>();

//     pthread_t c1, c2, p1, p2, p3;
//     pthread_create(&c1, nullptr, consumer, blq);
//     pthread_create(&c2, nullptr, consumer, blq);

//     pthread_create(&p1, nullptr, producer, blq);
//     pthread_create(&p2, nullptr, producer, blq);
//     pthread_create(&p3, nullptr, producer, blq);

//     pthread_join(c1, nullptr);
//     pthread_join(c2, nullptr);

//     pthread_join(p1, nullptr);
//     pthread_join(p2, nullptr);
//     pthread_join(p3, nullptr);
//     return 0;
// }

// #include <iostream>
// #include <vector>
// #include <ctime>
// #include <unistd.h>
// #include "Mythread.hpp"
// #include "SmartMutex.hpp"
// using namespace std;

// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

// int g_ticket = 1000;

// void *print(void *arg)
// {
//     string name = static_cast<const char *>(arg);

//     while (true)
//     {
//         pthread_mutex_lock(&mutex);
//         if (g_ticket > 0)
//         {
//             cout << "我是一个线程，线程名：" << name << " " << g_ticket-- << endl;
//         }
//         else
//         {
//             cout << "没有票了" << name << endl;
//             pthread_cond_wait(&cond, &mutex); // 在访问共享资源之前，要先查看有没有共享资源，等待
//         }

//         pthread_mutex_unlock(&mutex);
//         usleep(1000);
//     }

//     return nullptr;
// }

// int main()
// {
//     pthread_t tid1, tid2, tid3;
//     pthread_create(&tid1, nullptr, print, (void *)"thread-1");
//     pthread_create(&tid2, nullptr, print, (void *)"thread-2");
//     pthread_create(&tid2, nullptr, print, (void *)"thread-3");

//     while (true)
//     {
//         sleep(3);
//         pthread_mutex_lock(&mutex);
//         g_ticket += 1000;
//         pthread_mutex_unlock(&mutex);

//         pthread_cond_signal(&cond); // 逐一唤醒线程
//         // pthread_cond_broadcast(&cond); // 唤醒所有线程
//     }

//     pthread_join(tid1, nullptr);
//     pthread_join(tid2, nullptr);
//     pthread_join(tid3, nullptr);
//     return 0;
// }

// int Add(int x, int y)
// {
//     return x + y;
// }

// int main()
// {
//     int x = 0;
//     int y = 0;
//     int a = Add(x, y);
//     return 0;
// }

// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <unistd.h>
// #include <pthread.h>

// int ticket = 100;

// void *route(void *arg)
// {
//     char *id = (char *)arg;
//     while (1)
//     {
//         if (ticket > 0)
//         {
//             usleep(1000);
//             printf("%s sells ticket:%d\n", id, ticket);
//             ticket--;
//         }
//         else
//         {
//             break;
//         }
//     }
// }
// int main(void)
// {
//     pthread_t t1, t2, t3, t4;
//     pthread_create(&t1, nullptr, route, (void*)("thread 1"));
//     pthread_create(&t2, nullptr, route, (void*)("thread 2"));
//     pthread_create(&t3, nullptr, route, (void*)("thread 3"));
//     pthread_create(&t4, nullptr, route, (void*)("thread 4"));

//     pthread_join(t1, nullptr);
//     pthread_join(t2, nullptr);
//     pthread_join(t3, nullptr);
//     pthread_join(t4, nullptr);

//     return 0;
// }

// void print(int code)
// {
//     int cnt = 5;
//     while(cnt--)
//     {
//         cout << "new thread: " << code <<  endl;
//         sleep(1);
//     }
// }

// int g_ticket = 10000;

// void buyticket(pthread_mutex_t *mutex)
// {
//     sleep(2);

//     while (true)
//     {
//         {
//             SmartMutex smartmutex(mutex);
//             // 1. 上锁
//             // pthread_mutex_lock(mutex);
//             if (g_ticket > 0)
//             {
//                 usleep(1000);

//                 printf("购买票的编号：%d\n", g_ticket);
//                 g_ticket--;

//                 // 2. 解锁
//                 // pthread_mutex_unlock(mutex);
//             }
//             else
//             {
//                 // 2. 解锁
//                 // pthread_mutex_unlock(mutex);
//                 break;
//             }
//         }
//     }
// }

// int main()
// {
//     pthread_mutex_t mutex;
//     pthread_mutex_init(&mutex, nullptr);

//     const int num = 5;
//     vector<Thread<pthread_mutex_t *>> threads;

//     for (int i = 0; i < num; i++)
//     {
//         char name[64];
//         snprintf(name, sizeof(name), "%s-%d", "thread", i + 1);

//         // 将局部变量的锁可以作为参数给线程函数传过去
//         threads.push_back(Thread<pthread_mutex_t *>(name, buyticket, &mutex));
//     }

//     for (int i = 0; i < num; i++)
//     {
//         threads[i].Start();
//     }

//     for (int i = 0; i < num; i++)
//     {
//         cout << threads[i].IsRunning() << endl;
//     }

//     for (int i = 0; i < num; i++)
//     {
//         threads[i].Join();
//     }

//     time_t end = clock();

//     // 锁的销毁
//     pthread_mutex_destroy(&mutex);
//     return 0;
// }

pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER; // 全局的锁变量可以使用这个宏初始化

// void buyticket(int code)
// {
//     sleep(2);
//     (void)code;

//     while(true)
//     {
//         // 1. 上锁
//         // pthread_mutex_lock(&g_mutex);
//         if(g_ticket > 0)
//         {
//             usleep(1000);

//             printf("购买票的编号：%d\n", g_ticket);
//             g_ticket--;

//             // 2. 解锁
//             // pthread_mutex_unlock(&g_mutex);
//         }
//         else
//         {
//             // 2. 解锁
//             // pthread_mutex_unlock(&g_mutex);
//             break;
//         }
//     }
// }

// int main()
// {

//     time_t begin = clock();

//     const int num = 5;
//     vector<Thread<int>> threads;

//     for(int i = 0; i < num; i++)
//     {
//         char name[64];
//         snprintf(name, sizeof(name), "%s-%d", "thread", i + 1);
//         threads.push_back(Thread<int>(name, buyticket, 10));
//     }

//     for(int i = 0; i < num; i++)
//     {
//         threads[i].Start();
//     }

//         for(int i = 0; i < num; i++)
//     {
//         cout << threads[i].IsRunning() << endl;
//     }

//     for(int i = 0; i < num; i++)
//     {
//         threads[i].Join();
//     }

//     time_t end = clock();

//     cout << end - begin << endl;

//     pthread_mutex_destroy(&g_mutex);
//     return 0;
// }

// __thread int g_flag = 100;

// void *print(void *arg)
// {
//     while (true)
//     {
//         cout << "new thread: " << g_flag << " " << &g_flag <<endl;
//         sleep(1);
//         g_flag--;
//     }
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, print, nullptr);

//     sleep(2);
//     while (true)
//     {
//         cout << "main thread: " << g_flag << " " << &g_flag <<endl;
//         sleep(1);
//     }

//     pthread_join(tid, nullptr);
//     return 0;
// }

// void print()
// {
//     int cnt = 5;
//     while(cnt--)
//     {
//         cout << "new thread" << endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     thread s(print);

//     s.join();
//     return 0;
// }

// class threadret
// {
// public:
//     threadret(int64_t tid, string name, int code)
//         : _tid(tid)
//         , _name(name)
//         , _code(code)
//     {}

// public:
//     int64_t _tid;
//     string _name;
//     int _code;
// };

// class threadret
// {
// public:
//     threadret(int tid, string name, int code)
//         : _tid(tid)
//         , _name(name)
//         , _code(code)
//     {}

// public:
//     int _tid;
//     string _name;
//     int _code;
// };

// void* threadTask(void* arg)
// {
//     string name = static_cast<const char*>(arg);

//     int cnt = 5;
//     while(cnt--)
//     {
//         cout << "new thread, new thread id: " << pthread_self() << " name: " << name << endl;
//         sleep(1);
//     }

//     threadret* ret = new threadret(pthread_self(), name, 10);

//     pthread_exit((void*)ret);
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadTask, (void*)"thread-1");

//     sleep(5);

//     void* ret = nullptr;
//     int n = pthread_join(tid, &ret);
//     threadret* tret = static_cast<threadret*>(ret);

//     if(n == 0)
//     {
//         cout << "线程成功回收，" << "线程id：" << tret->_tid << " 退出信息: " << tret->_code <<  " 名字: " << tret->_name << endl;
//     }
//     delete tret;

//     return 0;
// }

// void* threadTask(void* arg)
// {
//     string name = static_cast<const char*>(arg);

//     int cnt = 10;
//     while(cnt--)
//     {
//         cout << "new thread, new thread id: " << pthread_self() << " name: " << name << endl;
//         sleep(1);
//     }

//     pthread_exit((void*)10);
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadTask, (void*)"thread-1");

//     sleep(5);

//     pthread_detach(tid);
//     cout << "线程分离" << endl;
//     int n = pthread_cancel(tid);
//     if(n == 0)
//     {
//         cout << "线程被取消" << endl;
//     }

//     void* ret = nullptr;
//     n = pthread_join(tid, &ret);

//     if(n == 0)
//     {
//         cout << "线程成功回收，" << "线程id：" << tid << "返回值: " << (int64_t)ret << endl;
//     }
//     else
//     {
//         cout << n << endl;
//     }

//     return 0;
// }

// void* threadTask(void* arg)
// {
//     while(true)
//     {
//         cout << "new thread, new thread id: " << pthread_self() << endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadTask, nullptr);

//     sleep(5);
//     while(true)
//     {
//         cout << "main thread, new thread id: " << tid  << " main thread id: " << pthread_self() << endl;
//         sleep(1);
//     }
//     return 0;
// }

// const int num = 5; // 创建线程的数目

// class mythread
// {
// public:
//     mythread(string name, string task)
//         : _name(name), _task(task)
//     {
//     }

// public:
//     string _name;
//     string _task;
// };

// void *task_thread(void *arg)
// {
//     mythread* thread = (mythread*)arg;
//     while (true)
//     {
//         cout << "我是一个线程，我的名字是： " << thread->_name << " 我的任务是： " << thread->_task << endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     vector<pthread_t> threadid;
//     for(int i = 0; i < num; i++)
//     {
//         pthread_t tid;
//         char name[64];
//         snprintf(name, sizeof(name), "%s-%d", "thread", i + 1);
//         mythread* thread = new mythread(name, "下载任务");
//         pthread_create(&tid, nullptr, task_thread, (void*)thread);

//         threadid.push_back(tid);
//     }
//     while(true)
//     {
//         for(int i = 0; i < num; i++)
//         {
//             cout << threadid[i] << " ";
//         }
//         cout << endl;
//         sleep(1);
//     }
//     return 0;
// }

// int main()
// {
//     pthread_t tid1;
//     const char *name1 = "thread-1";
//     pthread_create(&tid1, nullptr, task_thread, (void *)name1);

//     sleep(5);
//     while (true)
//     {
//         cout << "我是一个主进程，我的pid是：" << getpid() << endl;
//         sleep(1);
//     }

//     return 0;
// }

// void *task_thread(void *arg)
// {
//     int cnt = 5;
//     string name = (char *)arg;

//     while (true)
//     {
//         cout << "我是一个线程，我的名字是： " << (char *)arg << endl;
//         sleep(1);
//         cnt--;
//         if (cnt == 0)
//         {
//             if (name == "thread-4")
//             {
//                 int a = 10 / 0;
//             }
//         }
//     }
// }

// int main()
// {
//     pthread_t tid1;
//     const char *name1 = "thread-1";
//     pthread_create(&tid1, nullptr, task_thread, (void *)name1);

//     pthread_t tid2;
//     const char *name2 = "thread-2";
//     pthread_create(&tid2, nullptr, task_thread, (void *)name2);

//     pthread_t tid3;
//     const char *name3 = "thread-3";
//     pthread_create(&tid3, nullptr, task_thread, (void *)name3);

//     pthread_t tid4;
//     const char *name4 = "thread-4";
//     pthread_create(&tid4, nullptr, task_thread, (void *)name4);

//     pthread_t tid5;
//     const char *name5 = "thread-5";
//     pthread_create(&tid5, nullptr, task_thread, (void *)name5);

//     sleep(5);
//     while (true)
//     {
//         cout << "我是一个主进程，我的pid是：" << getpid() << endl;
//         sleep(1);
//     }

//     return 0;
// }